home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 #2 / Ham Radio 2000 - Volume 2.iso / HAMV2 / TCP_IP / TNOS230S / STATCONV.C < prev    next >
C/C++ Source or Header  |  1997-09-06  |  17KB  |  676 lines
  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include "ctype.h"
  6. #include "stats_a.h"
  7. #include "stats_f.h"
  8. #include "stats_h.h"
  9. #include "stats_m.h"
  10. #include "stats_t.h"
  11. #include "stats_u.h"
  12.  
  13.  
  14. static struct area_stats areastats;
  15. static struct fwd_stats fwdstats;
  16. static struct msg_stats msgstats;
  17. static struct tfc_stats tfcstats;
  18. static struct use_stats usestats;
  19. static struct http_stats httpstats;
  20.  
  21.  
  22. #define NULLFILE ((FILE *)0)
  23. #define NULLCHAR ((char *)0)
  24.  
  25. #define stricmp strcasecmp
  26. #define strnicmp strncasecmp
  27.  
  28. char *strupr(char *s);
  29. void rip (register char *s);
  30. void usage_exit (void);
  31. void saveastat (int num, long *data, const char *str);
  32. void finishSavingStat (time_t *data);
  33. void loadstats (void *beginning, void *ending);
  34. void area_import (void);
  35. void area_export (void);
  36. void forward_import (void);
  37. void forward_export (void);
  38. void http_import (void);
  39. void http_export (void);
  40. void message_import (void);
  41. void message_export (void);
  42. void traffic_import (void);
  43. void traffic_export (void);
  44. void usage_import (void);
  45. void usage_export (void);
  46. static struct fwd_data *create_f_entry (char *name, int add);
  47. static struct fwd_data *find_f_entry (char *name);
  48. static struct area_data *find_a_entry (char *name);
  49. static struct area_data *create_a_entry (char *name, int add);
  50.  
  51.  
  52. FILE *infp, *outfp;
  53.  
  54.  
  55. char *
  56. strupr (char *s)
  57. {
  58. register char *p = s;
  59.  
  60.     while (*p)
  61.         *p = (char) toupper (*p), p++;
  62.     return s;
  63. }
  64.  
  65.  
  66.  
  67. void
  68. rip (register char *s)
  69. {
  70. register char *cp;
  71.  
  72.     while ((cp = strchr (s, '\n')) != NULLCHAR || (cp = strchr (s, '\r')) != NULLCHAR)
  73.         *cp = '\0';
  74. }
  75.  
  76.  
  77.  
  78. void
  79. usage_exit (void)
  80. {
  81.     fprintf (stderr, "\nUsage: statconv <import | export> <type> <infile> [<outfile>]\n");
  82.     fprintf (stderr, "\twhere 'type' is area, forward, http, message, traffic, or usage\n");
  83.     exit (1);
  84. }
  85.  
  86.  
  87.  
  88. void
  89. saveastat (int num, long *data, const char *str)
  90. {
  91. int k;
  92.  
  93.     for (k = 0; k < num; k++)    {
  94.         fprintf (outfp, "%s[%d]: %ld", str, k, *data++);
  95.         fprintf (outfp, " %ld\n", *data++);
  96.     }
  97.  
  98. }
  99.  
  100.  
  101. void
  102. finishSavingStat (time_t *data)
  103. {
  104.     fprintf (outfp, "Start: %ld\n", (long) data[0]);
  105.     fprintf (outfp, "Last: %ld\n", (long) data[1]);
  106. }
  107.  
  108.  
  109.  
  110. void
  111. loadstats (void *beginning, void *ending)
  112. {
  113. char buffer[256], *cp;
  114. long *lp;
  115.  
  116.     lp = (long *)beginning;
  117.     while (!feof(infp))    {
  118.         (void) fgets (buffer, 79, infp);
  119.         if (feof(infp))
  120.             continue;
  121.         rip (buffer);
  122.         cp = strchr (buffer, ' ');
  123.         if (!cp)    {
  124.             fprintf (stderr, "Error in reading input file\n");
  125.             exit (1);
  126.         }
  127.         *lp++ = atol (++cp);
  128.         if (lp > (long *)ending)
  129.             break;
  130.         cp = strchr (cp, ' ');
  131.         if (cp)    {
  132.             *lp++ = atol (++cp);
  133.             if (lp > (long *)ending)
  134.                 break;
  135.         }
  136.     }
  137. }
  138.  
  139.  
  140.  
  141. static struct area_data *
  142. find_a_entry (char *name)
  143. {
  144. struct area_data *fd;
  145.  
  146.     fd = areastats.head;
  147.     while (fd)    {
  148.         if (!stricmp (name, fd->name))
  149.             return (fd);
  150.         fd = fd->next;
  151.     }
  152.     return ((struct area_data *)-1);
  153. }
  154.  
  155.  
  156. static struct area_data *
  157. create_a_entry (char *name, int add)
  158. {
  159. struct area_data *fd;
  160.  
  161.     fd = find_a_entry (name);
  162.     if (fd == (struct area_data *)-1)    {
  163.         fd = calloc (1, sizeof (struct area_data)); /* no error checking, yet */
  164.         if (fd != (struct area_data *)0)    {
  165.             fd->name = strdup (name);
  166.             (void) strupr (fd->name);
  167.             fd->next = areastats.head;
  168.             areastats.head = fd;
  169.             if (add)
  170.                 areastats.count++;
  171.         }
  172.     }
  173.     return (fd);
  174. }
  175.  
  176.  
  177. void
  178. area_import (void)
  179. {
  180. int count;
  181. struct area_data *fd;
  182. char buffer[256], *cp;
  183. long *lp;
  184.  
  185.     /* read in the ascii version */
  186.     (void) fgets (buffer, 79, infp);
  187.     if (feof(infp))
  188.         goto done;
  189.     rip (buffer);
  190.     cp = strchr (buffer, ' ');
  191.     if (!cp)    {
  192.         fprintf (stderr, "Error in loading stats file\n");
  193.         exit (1);
  194.     }
  195.     areastats.days = atol (++cp);
  196.     while (!feof(infp))    {
  197.         (void) fgets (buffer, 79, infp);
  198.         if (feof(infp))
  199.             continue;
  200.         rip (buffer);
  201.         if (strnicmp (buffer, "Name:", 5))
  202.             break;
  203.         fd = create_a_entry (&buffer[6], 1);
  204.         lp = (long *)&fd->usage;    /*lint !e545 */
  205.         while (!feof(infp))    {
  206.             (void) fgets (buffer, 79, infp);
  207.             if (feof(infp))
  208.                 continue;
  209.             rip (buffer);
  210.             cp = strchr (buffer, ' ');
  211.             if (!cp)    {
  212.                 fprintf (stderr, "Error in loading stats file\n");
  213.                 exit (1);
  214.             }
  215.             *lp++ = atol (++cp);
  216.             if (lp > (long *)&fd->month2[1])
  217.                 break;
  218.             cp = strchr (cp, ' ');
  219.             if (cp)    {
  220.                 *lp++ = atol (++cp);
  221.                 if (lp > (long *)&fd->month2[1])
  222.                     break;
  223.             }
  224.         }
  225.     }
  226.     if (!feof(infp))    {
  227.         cp = strchr (buffer, ' ');
  228.         if (!cp)    {
  229.             fprintf (stderr, "Error in loading stats file\n");
  230.             exit (1);
  231.         }
  232.         areastats.start = atol (++cp);
  233.  
  234.         (void) fgets (buffer, 79, infp);
  235.         if (feof(infp))
  236.             goto done;
  237.         rip (buffer);
  238.         cp = strchr (buffer, ' ');
  239.         if (!cp)    {
  240.             fprintf (stderr, "Error in loading stats file\n");
  241.             exit (1);
  242.         }
  243.         areastats.last = atol (++cp);
  244.     }
  245. done:    
  246.  
  247.     /* and output the binary version */
  248.     fwrite (&areastats, sizeof (struct area_stats) - sizeof(struct area_data *), 1, outfp);
  249.     fd = areastats.head;
  250.     for (count = 0; count < areastats.count; count++, fd = fd->next)    {
  251.         fprintf (outfp, "%c%s", strlen (fd->name), fd->name);
  252.         fwrite (fd->usage, sizeof (struct area_data) - (sizeof(char *) + sizeof(struct area_data *)), 1, outfp);    /*lint !e420 */
  253.     }
  254. }
  255.  
  256.  
  257.  
  258. void
  259. area_export (void)
  260. {
  261. char buffer[256];
  262. int count;
  263. struct area_data *fd;
  264. int len;
  265.  
  266.     /* read in the binary version */
  267.     (void) fread (&areastats, sizeof (struct area_stats) - sizeof(struct area_data *), 1, infp);
  268.     for (count = 0; count < areastats.count; count++)    {
  269.         len = fgetc (infp);
  270.         (void) fread (buffer, (unsigned) len, 1, infp);
  271.         buffer[len] = 0;
  272.         fd = create_a_entry (buffer, 0);
  273.         (void) fread (fd->usage, sizeof (struct area_data) - (sizeof(char *) + sizeof(struct area_data *)), 1, infp);    /*lint !e419 */
  274.     }
  275.  
  276.     /* output the ascii version */
  277.     fprintf (outfp, "Days: %ld\n", areastats.days);
  278.     fd = areastats.head;
  279.     for (count = 0; count < areastats.count; count++, fd = fd->next)    {
  280.         fprintf (outfp, "Name: %s\n", fd->name);
  281.         fprintf (outfp, "Usage: %ld %ld\n", fd->usage[0], fd->usage[1]);
  282.         fprintf (outfp, "Usage2: %ld %ld\n", fd->usage2[0], fd->usage2[1]);
  283.         saveastat (24, &fd->hourly[0][0], "Hourly");
  284.         saveastat (24, &fd->hourly2[0][0], "Hourly2");
  285.         saveastat (7, &fd->daily[0][0], "Daily");
  286.         saveastat (7, &fd->daily2[0][0], "Daily2");
  287.         saveastat (31, &fd->monthly[0][0], "Monthly");
  288.         saveastat (31, &fd->monthly2[0][0], "Monthly2");
  289.         saveastat (12, &fd->yearly[0][0], "Yearly");
  290.         saveastat (12, &fd->yearly2[0][0], "Yearly2");
  291.         fprintf (outfp, "Hour: %ld %ld\n", fd->hour[0], fd->hour[1]);
  292.         fprintf (outfp, "Hour2: %ld %ld\n", fd->hour2[0], fd->hour2[1]);
  293.         fprintf (outfp, "Day: %ld %ld\n", fd->day[0], fd->day[1]);
  294.         fprintf (outfp, "Day2: %ld %ld\n", fd->day2[0], fd->day2[1]);
  295.         fprintf (outfp, "Month: %ld %ld\n", fd->month[0], fd->month[1]);
  296.         fprintf (outfp, "Month2: %ld %ld\n", fd->month2[0], fd->month2[1]);
  297.     }
  298.     finishSavingStat (&areastats.start);
  299. }
  300.  
  301.  
  302.  
  303. static struct fwd_data *
  304. find_f_entry (name)
  305. char *name;
  306. {
  307. struct fwd_data *fd;
  308.  
  309.     fd = fwdstats.head;
  310.     while (fd)    {
  311.         if (!stricmp (name, fd->name))
  312.             return (fd);
  313.         fd = fd->next;
  314.     }
  315.     return ((struct fwd_data *)-1);
  316. }
  317.  
  318.  
  319. static struct fwd_data *
  320. create_f_entry (name, add)
  321. char *name;
  322. int add;
  323. {
  324. struct fwd_data *fd;
  325.  
  326.     fd = find_f_entry (name);
  327.     if (fd == (struct fwd_data *)-1)    {
  328.         fd = calloc (1, sizeof (struct fwd_data)); /* no error checking, yet */
  329.         if (fd != (struct fwd_data *)0)    {
  330.             fd->name = strdup (name);
  331.             (void) strupr (fd->name);
  332.             fd->next = fwdstats.head;
  333.             fwdstats.head = fd;
  334.             if (add)
  335.                 fwdstats.count++;
  336.         }
  337.     }
  338.     return (fd);
  339. }
  340.  
  341.  
  342.  
  343. void
  344. forward_import (void)
  345. {
  346. int count;
  347. struct fwd_data *fd;
  348. char buffer[256], *cp;
  349. long *lp;
  350.  
  351.     /* read in the ascii version */
  352.     (void) fgets (buffer, 79, infp);
  353.     if (feof(infp))
  354.         goto done;
  355.     rip (buffer);
  356.     cp = strchr (buffer, ' ');
  357.     if (!cp)    {
  358.         fprintf (stderr, "Error in loading stats file\n");
  359.         exit (1);
  360.     }
  361.     fwdstats.days = atol (++cp);
  362.     while (!feof(infp))    {
  363.         (void) fgets (buffer, 79, infp);
  364.         if (feof(infp))
  365.             continue;
  366.         rip (buffer);
  367.         if (strnicmp (buffer, "Name:", 5))
  368.             break;
  369.         fd = create_f_entry (&buffer[6], 1);
  370.         lp = (long *)&fd->messages;    /*lint !e545 */
  371.         while (!feof(infp))    {
  372.             (void) fgets (buffer, 79, infp);
  373.             if (feof(infp))
  374.                 continue;
  375.             rip (buffer);
  376.             cp = strchr (buffer, ' ');
  377.             if (!cp)    {
  378.                 fprintf (stderr, "Error in loading stats file\n");
  379.                 exit (1);
  380.             }
  381.             *lp++ = atol (++cp);
  382.             if (lp > (long *)&fd->month[1])
  383.                 break;
  384.             cp = strchr (cp, ' ');
  385.             if (cp)    {
  386.                 *lp++ = atol (++cp);
  387.                 if (lp > (long *)&fd->month[1])
  388.                     break;
  389.             }
  390.         }
  391.     }
  392.     if (!feof(infp))    {
  393.         cp = strchr (buffer, ' ');
  394.         if (!cp)    {
  395.             fprintf (stderr, "Error in loading stats file\n");
  396.             exit (1);
  397.         }
  398.         fwdstats.start = atol (++cp);
  399.  
  400.         (void) fgets (buffer, 79, infp);
  401.         if (feof(infp))
  402.             goto done;
  403.         rip (buffer);
  404.         cp = strchr (buffer, ' ');
  405.         if (!cp)    {
  406.             fprintf (stderr, "Error in loading stats file\n");
  407.             exit (1);
  408.         }
  409.         fwdstats.last = atol (++cp);
  410.     }
  411. done:    
  412.  
  413.     /* and output the binary version */
  414.     fwrite (&fwdstats, sizeof (struct fwd_stats) - sizeof(struct fwd_data *), 1, outfp);
  415.     fd = fwdstats.head;
  416.     for (count = 0; count < fwdstats.count; count++, fd = fd->next)    {
  417.         fprintf (outfp, "%c%s", strlen (fd->name), fd->name);
  418.         fwrite (fd->messages, sizeof (struct fwd_data) - (sizeof(char *) + sizeof(struct fwd_data *)), 1, outfp);    /*lint !e420 */
  419.     }
  420. }
  421.  
  422.  
  423.  
  424. void
  425. forward_export (void)
  426. {
  427. char buffer[256];
  428. int count;
  429. struct fwd_data *fd;
  430. int len;
  431.  
  432.     /* read in the binary version */
  433.     (void) fread (&fwdstats, sizeof (struct fwd_stats) - sizeof(struct fwd_data *), 1, infp);
  434.     for (count = 0; count < fwdstats.count; count++)    {
  435.         len = fgetc (infp);
  436.         (void) fread (buffer, (unsigned) len, 1, infp);
  437.         buffer[len] = 0;
  438.         fd = create_f_entry (buffer, 0);
  439.         (void) fread (fd->messages, sizeof (struct fwd_data) - (sizeof(char *) + sizeof(struct fwd_data *)), 1, infp);    /*lint !e419 */
  440.     }
  441.  
  442.     /* output the ascii version */
  443.     fprintf (outfp, "Days: %ld\n", fwdstats.days);
  444.     fd = fwdstats.head;
  445.     for (count = 0; count < fwdstats.count; count++, fd = fd->next)    {
  446.         fprintf (outfp, "Name: %s\n", fd->name);
  447.         fprintf (outfp, "Messages: %ld %ld\n", fd->messages[0], fd->messages[1]);
  448.         saveastat (24, &fd->hourly[0][0], "Hourly");
  449.         saveastat (7, &fd->daily[0][0], "Daily");
  450.         saveastat (31, &fd->monthly[0][0], "Monthly");
  451.         saveastat (12, &fd->yearly[0][0], "Yearly");
  452.         fprintf (outfp, "Hour: %ld %ld\n",    fd->hour[0], fd->hour[1]);
  453.         fprintf (outfp, "Day: %ld %ld\n", fd->day[0], fd->day[1]);
  454.         fprintf (outfp, "Month: %ld %ld\n", fd->month[0], fd->month[1]);
  455.     }
  456.     finishSavingStat (&fwdstats.start);
  457. }
  458.  
  459.  
  460.  
  461. void
  462. http_import (void)
  463. {
  464.     /* read in the ascii version */
  465.     loadstats (&httpstats, &httpstats.last);
  466.  
  467.     /* and output the binary version */
  468.     fwrite (&httpstats, sizeof (struct http_stats), 1, outfp);
  469. }
  470.  
  471.  
  472.  
  473. void
  474. http_export (void)
  475. {
  476.     /* read in the binary version */
  477.     (void) fread (&httpstats, sizeof (struct http_stats), 1, infp);
  478.     
  479.     /* output the ascii version */
  480.     fprintf (outfp, "Days: %ld\nTotalRequests: %ld %ld\n",
  481.         httpstats.days, httpstats.connects[0], httpstats.connects[1]);
  482.     fprintf (outfp, "DailyRequests: %ld %ld\n",
  483.         httpstats.dailyconnects[0], httpstats.dailyconnects[1]);
  484.     saveastat (24, &httpstats.hourly[0][0], "Hourly");
  485.     saveastat (7, &httpstats.daily[0][0], "Daily");
  486.     saveastat (31, &httpstats.monthly[0][0], "Monthly");
  487.     saveastat (12, &httpstats.yearly[0][0], "Yearly");
  488.     fprintf (outfp, "Hour: %ld %ld\n", httpstats.hour[0], httpstats.hour[1]);
  489.     fprintf (outfp, "Day: %ld %ld\n", httpstats.day[0], httpstats.day[1]);
  490.     fprintf (outfp, "Month: %ld %ld\n", httpstats.month[0], httpstats.month[1]);
  491.     finishSavingStat (&httpstats.start);
  492. }
  493.  
  494.  
  495.  
  496. void
  497. message_import (void)
  498. {
  499.     /* read in the ascii version */
  500.     loadstats (&msgstats, &msgstats.last);
  501.  
  502.     /* and output the binary version */
  503.     fwrite (&msgstats, sizeof (struct msg_stats), 1, outfp);
  504. }
  505.  
  506.  
  507.  
  508. void
  509. message_export (void)
  510. {
  511.     /* read in the binary version */
  512.     (void) fread (&msgstats, sizeof (struct msg_stats), 1, infp);
  513.     
  514.     /* output the ascii version */
  515.     fprintf (outfp, "Days: %ld\nMessages: %ld %ld\n",
  516.         msgstats.days, msgstats.messages[0], msgstats.messages[1]);
  517.     saveastat (24, &msgstats.hourly[0][0], "Hourly");
  518.     saveastat (7, &msgstats.daily[0][0], "Daily");
  519.     saveastat (31, &msgstats.monthly[0][0], "Monthly");
  520.     saveastat (12, &msgstats.yearly[0][0], "Yearly");
  521.     fprintf (outfp, "Hour: %ld %ld\n", msgstats.hour[0], msgstats.hour[1]);
  522.     fprintf (outfp, "Day: %ld %ld\n", msgstats.day[0], msgstats.day[1]);
  523.     fprintf (outfp, "Month: %ld %ld\n", msgstats.month[0], msgstats.month[1]);
  524.     finishSavingStat (&msgstats.start);
  525. }
  526.  
  527.  
  528.  
  529. void
  530. traffic_import (void)
  531. {
  532.     /* read in the ascii version */
  533.     loadstats (&tfcstats, &tfcstats.last);
  534.  
  535.     /* and output the binary version */
  536.     fwrite (&tfcstats, sizeof (struct tfc_stats), 1, outfp);
  537. }
  538.  
  539.  
  540.  
  541. void
  542. traffic_export (void)
  543. {
  544.     /* read in the binary version */
  545.     (void) fread (&tfcstats, sizeof (struct tfc_stats), 1, infp);
  546.     
  547.     /* output the ascii version */
  548.     fprintf (outfp, "Days: %ld\nMessages: %ld %ld\n",
  549.         tfcstats.days, tfcstats.messages[0], tfcstats.messages[1]);
  550.     fprintf (outfp, "Messages2: %ld %ld\n", tfcstats.messages2[0], tfcstats.messages2[1]);
  551.     saveastat (24, &tfcstats.hourly[0][0], "Hourly");
  552.     saveastat (24, &tfcstats.hourly2[0][0], "Hourly2");
  553.     saveastat (7, &tfcstats.daily[0][0], "Daily");
  554.     saveastat (7, &tfcstats.daily2[0][0], "Daily2");
  555.     saveastat (31, &tfcstats.monthly[0][0], "Monthly");
  556.     saveastat (31, &tfcstats.monthly2[0][0], "Monthly2");
  557.     saveastat (12, &tfcstats.yearly[0][0], "Yearly");
  558.     saveastat (12, &tfcstats.yearly2[0][0], "Yearly2");
  559.     fprintf (outfp, "Hour: %ld %ld\n", tfcstats.hour[0], tfcstats.hour[1]);
  560.     fprintf (outfp, "Hour2: %ld %ld\n", tfcstats.hour2[0], tfcstats.hour2[1]);
  561.     fprintf (outfp, "Day: %ld %ld\n", tfcstats.day[0], tfcstats.day[1]);
  562.     fprintf (outfp, "Day2: %ld %ld\n", tfcstats.day2[0], tfcstats.day2[1]);
  563.     fprintf (outfp, "Month: %ld %ld\n", tfcstats.month[0], tfcstats.month[1]);
  564.     fprintf (outfp, "Month2: %ld %ld\n", tfcstats.month2[0], tfcstats.month2[1]);
  565.     finishSavingStat (&tfcstats.start);
  566. }
  567.  
  568.  
  569.  
  570. void
  571. usage_import (void)
  572. {
  573.     /* read in the ascii version */
  574.     loadstats (&usestats, &usestats.last);
  575.  
  576.     /* and output the binary version */
  577.     fwrite (&usestats, sizeof (struct use_stats), 1, outfp);
  578. }
  579.  
  580.  
  581.  
  582. void
  583. usage_export (void)
  584. {
  585.     /* read in the binary version */
  586.     (void) fread (&usestats, sizeof (struct use_stats), 1, infp);
  587.     
  588.     /* output the ascii version */
  589.     fprintf (outfp, "Days: %ld\nConnects: %ld %ld\n",
  590.         usestats.days, usestats.connects[0], usestats.connects[1]);
  591.     fprintf (outfp, "Dailyconnects: %ld %ld\n",
  592.         usestats.dailyconnects[0], usestats.dailyconnects[1]);
  593.     fprintf (outfp, "Usage: %ld %ld\n", usestats.usage[0], usestats.usage[1]);
  594.     saveastat (24, &usestats.hourly[0][0], "Hourly");
  595.     saveastat (7, &usestats.daily[0][0], "Daily");
  596.     saveastat (31, &usestats.monthly[0][0], "Monthly");
  597.     saveastat (12, &usestats.yearly[0][0], "Yearly");
  598.     fprintf (outfp, "Hour: %ld %ld\n", usestats.hour[0], usestats.hour[1]);
  599.     fprintf (outfp, "Day: %ld %ld\n", usestats.day[0], usestats.day[1]);
  600.     fprintf (outfp, "Month: %ld %ld\n", usestats.month[0], usestats.month[1]);
  601.     finishSavingStat (&usestats.start);
  602. }
  603.  
  604.  
  605.  
  606. int
  607. main (int argc, char *argv[])
  608. {
  609. int mode = 0;
  610.  
  611.     if (argc < 4)
  612.         usage_exit ();
  613.  
  614.     outfp = stdout;
  615.     if (tolower (argv[1][0]) == 'e')
  616.         mode = 1;
  617.  
  618.     infp = fopen (argv[3], "r");
  619.     if (infp == NULLFILE)    {
  620.         fprintf (stderr, "\nCan't open input file: '%s'\n", argv[3]);
  621.         usage_exit ();
  622.     }
  623.  
  624.     if (argc > 4)    {
  625.         outfp = fopen (argv[4], "w");
  626.         if (outfp == NULLFILE)    {
  627.             fprintf (stderr, "\nCan't open input file: '%s'\n", argv[4]);
  628.             usage_exit ();
  629.         }
  630.     }
  631.  
  632.     switch (tolower (argv[2][0]))    {
  633.         case 'a':    /* area file */
  634.                 if (mode)
  635.                     area_export ();
  636.                 else
  637.                     area_import ();
  638.                 break;
  639.         case 'f':    /* forward file */
  640.                 if (mode)
  641.                     forward_export ();
  642.                 else
  643.                     forward_import ();
  644.                 break;
  645.         case 'h':    /* http file */
  646.                 if (mode)
  647.                     http_export ();
  648.                 else
  649.                     http_import ();
  650.                 break;
  651.         case 'm':    /* message file */
  652.                 if (mode)
  653.                     message_export ();
  654.                 else
  655.                     message_import ();
  656.                 break;
  657.         case 't':    /* traffic file */
  658.                 if (mode)
  659.                     traffic_export ();
  660.                 else
  661.                     traffic_import ();
  662.                 break;
  663.         case 'u':    /* usage file */
  664.                 if (mode)
  665.                     usage_export ();
  666.                 else
  667.                     usage_import ();
  668.                 break;
  669.         default:    /* error!!! */
  670.                 fprintf (stderr, "\nInvalid file type: '%s'\n", argv[2]);
  671.                 usage_exit ();            
  672.     }
  673.     return 0;
  674. }
  675.  
  676.